ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಸಹಾಯಕ ಸಂಪನ್ಮೂಲ ಪೂಲ್: ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ

ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಅಸಿಂಕ್ರೊನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮೂಲಭೂತವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು, ಫೈಲ್ ಸಿಸ್ಟಮ್ ಪ್ರವೇಶ ಮತ್ತು ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳಂತಹ I/O-ಬೌಂಡ್ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ES2018 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು, ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾದ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಬಳಸಲು ಪ್ರಬಲವಾದ ಕಾರ್ಯವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಈ ಸ್ಟ್ರೀಮ್‌ಗಳಲ್ಲಿ ಅಸಿಂಕ್ರೊನಸ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಸವಾಲಿನ ಸಂಗತಿಯಾಗಿದೆ. ಈ ಲೇಖನವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳ ಕೊರತೆಯನ್ನು ತಡೆಯಲು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಸಹಾಯಕ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ದೃಢವಾದ ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಎನ್ನುವುದು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್‌ಗೆ ಅನುಗುಣವಾಗಿರುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ. ಇದು `next()` ಮೆಥೆಡ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಇದು `value` ಮತ್ತು `done` ಎಂಬ ಎರಡು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಪರಿಹಾರವಾಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. `value` ಪ್ರಾಪರ್ಟಿಯು ಅನುಕ್ರಮದಲ್ಲಿ ಮುಂದಿನ ಐಟಂ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು `done` ಪ್ರಾಪರ್ಟಿಯು ಇಟರೇಟರ್ ಅನುಕ್ರಮದ ಅಂತ್ಯವನ್ನು ತಲುಪಿದೆಯೇ ಎಂದು ಸೂಚಿಸುವ ಬೂಲಿಯನ್ ಆಗಿದೆ. ಸಾಮಾನ್ಯ ಇಟರೇಟರ್‌ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, `next()` ಗೆ ಪ್ರತಿಯೊಂದು ಕರೆಯೂ ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿರಬಹುದು, ಇದು ನಿಮಗೆ ಡೇಟಾವನ್ನು ನಾನ್-ಬ್ಲಾಕಿಂಗ್ ರೀತಿಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವನ್ನು ಉತ್ಪಾದಿಸುವ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನ ಸರಳ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            
async function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    await delay(100); // Simulate asynchronous operation
    yield i;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

(async () => {
  for await (const number of numberGenerator(5)) {
    console.log(number);
  }
})();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `numberGenerator` ಒಂದು ಅಸಿಂಕ್ ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಆಗಿದೆ. `yield` ಕೀವರ್ಡ್ ಜನರೇಟರ್ ಫಂಕ್ಷನ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನೀಡಲಾದ ಮೌಲ್ಯದೊಂದಿಗೆ ಪರಿಹಾರವಾಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. `for await...of` ಲೂಪ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ನಿಂದ ಉತ್ಪತ್ತಿಯಾದ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.

ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯ ಅವಶ್ಯಕತೆ

ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ನೀವು ದೊಡ್ಡ ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿರುವ, ಹಲವಾರು API ಕರೆಗಳನ್ನು ಮಾಡುತ್ತಿರುವ ಅಥವಾ ಡೇಟಾಬೇಸ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಿರುವ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ. ಸರಿಯಾದ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಇಲ್ಲದಿದ್ದರೆ, ನೀವು ಸುಲಭವಾಗಿ ಸಿಸ್ಟಮ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಖಾಲಿ ಮಾಡಬಹುದು, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಕುಸಿತ, ದೋಷಗಳು ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳಲ್ಲಿನ ಕೆಲವು ಸಾಮಾನ್ಯ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣಾ ಸವಾಲುಗಳು ಇಲ್ಲಿವೆ:

• ಕನ್‌ಕರೆನ್ಸಿ ಮಿತಿಗಳು: ಅತಿಯಾದ ಕನ್‌ಕರೆಂಟ್ ವಿನಂತಿಗಳನ್ನು ಮಾಡುವುದರಿಂದ ಸರ್ವರ್‌ಗಳು ಅಥವಾ ಡೇಟಾಬೇಸ್‌ಗಳ ಮೇಲೆ ಹೊರೆಯಾಗಬಹುದು.
• ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆ: ಸಂಪನ್ಮೂಲಗಳನ್ನು (ಉದಾ., ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳು, ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳು) ಬಿಡುಗಡೆ ಮಾಡಲು ವಿಫಲವಾದರೆ ಸಂಪನ್ಮೂಲಗಳ ಕೊರತೆಗೆ ಕಾರಣವಾಗಬಹುದು.
• ದೋಷ ನಿರ್ವಹಣೆ: ದೋಷಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ದೋಷಗಳು ಸಂಭವಿಸಿದಾಗಲೂ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಸಹಾಯಕ ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಸಹಾಯಕ ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಕಾರ್ಯವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದನ್ನು ಅನೇಕ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ನಡುವೆ ಹಂಚಿಕೊಳ್ಳಬಹುದು. ಇದು ಕನ್‌ಕರೆನ್ಸಿಯನ್ನು ನಿಯಂತ್ರಿಸಲು, ಸಂಪನ್ಮೂಲಗಳ ಕೊರತೆಯನ್ನು ತಡೆಯಲು ಮತ್ತು ಒಟ್ಟಾರೆ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಪೂಲ್‌ನಿಂದ ಸಂಪನ್ಮೂಲವನ್ನು ಪಡೆದುಕೊಳ್ಳುವುದು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಂಡಾಗ ಅದನ್ನು ಪೂಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸುವುದು ಇದರ মূল ಕಲ್ಪನೆಯಾಗಿದೆ.

ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ನ ಪ್ರಮುಖ ಘಟಕಗಳು

1. ಸಂಪನ್ಮೂಲ ರಚನೆ: ಹೊಸ ಸಂಪನ್ಮೂಲವನ್ನು (ಉದಾ., ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ, API ಕ್ಲೈಂಟ್) ರಚಿಸುವ ಫಂಕ್ಷನ್.
2. ಸಂಪನ್ಮೂಲ ನಾಶ: ಸಂಪನ್ಮೂಲವನ್ನು (ಉದಾ., ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುವುದು, API ಕ್ಲೈಂಟ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದು) ನಾಶಪಡಿಸುವ ಫಂಕ್ಷನ್.
3. ಸ್ವಾಧೀನ: ಪೂಲ್‌ನಿಂದ ಉಚಿತ ಸಂಪನ್ಮೂಲವನ್ನು ಪಡೆದುಕೊಳ್ಳುವ ಮೆಥೆಡ್. ಯಾವುದೇ ಸಂಪನ್ಮೂಲಗಳು ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೆ, ಸಂಪನ್ಮೂಲ ಲಭ್ಯವಾಗುವವರೆಗೆ ಅದು ಕಾಯುತ್ತದೆ.
4. ಬಿಡುಗಡೆ: ಸಂಪನ್ಮೂಲವನ್ನು ಪೂಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸುವ ಮೆಥೆಡ್, ಅದನ್ನು ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ.
5. ಪೂಲ್ ಗಾತ್ರ: ಪೂಲ್ ನಿರ್ವಹಿಸಬಹುದಾದ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಸಂಪನ್ಮೂಲಗಳು.

ಅನುಷ್ಠಾನದ ಉದಾಹರಣೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಸಹಾಯಕ ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ನ ಅನುಷ್ಠಾನದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            
class ResourcePool {
  constructor(resourceFactory, resourceDestroyer, poolSize) {
    this.resourceFactory = resourceFactory;
    this.resourceDestroyer = resourceDestroyer;
    this.poolSize = poolSize;
    this.availableResources = [];
    this.acquiredResources = new Set();
    this.waitingQueue = [];

    // Pre-populate the pool with initial resources
    for (let i = 0; i < poolSize; i++) {
      this.availableResources.push(resourceFactory());
    }
  }

  async acquire() {
    if (this.availableResources.length > 0) {
      const resource = this.availableResources.pop();
      this.acquiredResources.add(resource);
      return resource;
    } else {
      return new Promise(resolve => {
        this.waitingQueue.push(resolve);
      });
    }
  }

  release(resource) {
    if (this.acquiredResources.has(resource)) {
      this.acquiredResources.delete(resource);
      this.availableResources.push(resource);

      if (this.waitingQueue.length > 0) {
        const resolve = this.waitingQueue.shift();
        resolve(this.availableResources.pop());
      }
    } else {
      console.warn("Releasing a resource that wasn't acquired from this pool.");
    }
  }

  async destroy() {
    for (const resource of this.availableResources) {
      await this.resourceDestroyer(resource);
    }
    this.availableResources = [];

    for (const resource of this.acquiredResources) {
      await this.resourceDestroyer(resource);
    }
    this.acquiredResources.clear();
  }
}

// Example usage with a hypothetical database connection
async function createDatabaseConnection() {
  // Simulate creating a database connection
  await delay(50);
  return { id: Math.random(), status: 'connected' };
}

async function closeDatabaseConnection(connection) {
  // Simulate closing a database connection
  await delay(50);
  console.log(`Closing connection ${connection.id}`);
}

(async () => {
  const poolSize = 5;
  const dbPool = new ResourcePool(createDatabaseConnection, closeDatabaseConnection, poolSize);

  async function processData(data) {
    const connection = await dbPool.acquire();
    console.log(`Processing data ${data} with connection ${connection.id}`);
    await delay(100); // Simulate database operation
    dbPool.release(connection);
  }

  const dataToProcess = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  const promises = dataToProcess.map(data => processData(data));
  await Promise.all(promises);

  await dbPool.destroy();
})();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• `ResourcePool` ಎಂಬುದು ಸಂಪನ್ಮೂಲಗಳ ಪೂಲ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ಕ್ಲಾಸ್ ಆಗಿದೆ.
• `resourceFactory` ಎಂಬುದು ಹೊಸ ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ರಚಿಸುವ ಫಂಕ್ಷನ್ ಆಗಿದೆ.
• `resourceDestroyer` ಎಂಬುದು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುವ ಫಂಕ್ಷನ್ ಆಗಿದೆ.
• `acquire()` ಪೂಲ್‌ನಿಂದ ಸಂಪರ್ಕವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ.
• `release()` ಸಂಪರ್ಕವನ್ನು ಪೂಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• `destroy()` ಪೂಲ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಾಶಪಡಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು

ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುತ್ತಾ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನೀವು ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸಬಹುದು. ಇಲ್ಲಿದೆ ಒಂದು ಉದಾಹರಣೆ:

            
async function* processStream(dataStream, resourcePool) {
  for await (const data of dataStream) {
    const resource = await resourcePool.acquire();
    try {
      // Process the data using the acquired resource
      const result = await processData(data, resource);
      yield result;
    } finally {
      resourcePool.release(resource);
    }
  }
}

async function processData(data, resource) {
  // Simulate processing data with the resource
  await delay(50);
  return `Processed ${data} with resource ${resource.id}`;
}

(async () => {
    const poolSize = 3;
    const dbPool = new ResourcePool(createDatabaseConnection, closeDatabaseConnection, poolSize);

    async function* generateData() {
        for (let i = 1; i <= 10; i++) {
            await delay(20);
            yield i;
        }
    }

    const dataStream = generateData();
    const results = [];
    for await (const result of processStream(dataStream, dbPool)) {
        results.push(result);
        console.log(result);
    }

    await dbPool.destroy();
})();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `processStream` ಎಂಬುದು ಅಸಿಂಕ್ ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಇದು ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ನಿಂದ ಪಡೆದ ಸಂಪನ್ಮೂಲವನ್ನು ಬಳಸಿ ಪ್ರತಿ ಐಟಂ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. `try...finally` ಬ್ಲಾಕ್, ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದರೂ ಸಹ, ಸಂಪನ್ಮೂಲವನ್ನು ಯಾವಾಗಲೂ ಪೂಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು

• ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ: ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡುವುದರಿಂದ, ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಗೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ರಚಿಸುವ ಮತ್ತು ನಾಶಪಡಿಸುವ ಹೊರೆ ತಪ್ಪಿಸಬಹುದು.
• ನಿಯಂತ್ರಿತ ಕನ್‌ಕರೆನ್ಸಿ: ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಕನ್‌ಕರೆಂಟ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ, ಸಂಪನ್ಮೂಲಗಳ ಕೊರತೆಯನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಸಿಸ್ಟಮ್ ಸ್ಥಿರತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
• ಸರಳೀಕೃತ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ: ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳುವ ಮತ್ತು ಬಿಡುಗಡೆ ಮಾಡುವ ತರ್ಕವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
• ವರ್ಧಿತ ದೋಷ ನಿರ್ವಹಣೆ: ದೋಷಗಳು ಸಂಭವಿಸಿದಾಗಲೂ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ.

ಸುಧಾರಿತ ಪರಿಗಣನೆಗಳು

ಸಂಪನ್ಮೂಲ ಮೌಲ್ಯೀಕರಣ

ಸಂಪನ್ಮೂಲಗಳು ಇನ್ನೂ ಮಾನ್ಯವಾಗಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅವುಗಳನ್ನು ಬಳಸುವ ಮೊದಲು ಮೌಲ್ಯೀಕರಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಉದಾಹರಣೆಗೆ, ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಬಳಸುವ ಮೊದಲು ಅದು ಇನ್ನೂ ಸಕ್ರಿಯವಾಗಿದೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು. ಒಂದು ಸಂಪನ್ಮೂಲ ಅಮಾನ್ಯವಾಗಿದ್ದರೆ, ನೀವು ಅದನ್ನು ನಾಶಪಡಿಸಿ ಪೂಲ್‌ನಿಂದ ಹೊಸದನ್ನು ಪಡೆದುಕೊಳ್ಳಬಹುದು.

            
class ResourcePool {
  // ... (previous code) ...

  async acquire() {
    while (true) {
      if (this.availableResources.length > 0) {
        const resource = this.availableResources.pop();
        if (await this.isValidResource(resource)) {
          this.acquiredResources.add(resource);
          return resource;
        } else {
          console.warn("Invalid resource detected, destroying and acquiring a new one.");
          await this.resourceDestroyer(resource);
          // Attempt to acquire another resource (loop continues)
        }
      } else {
        return new Promise(resolve => {
          this.waitingQueue.push(resolve);
        });
      }
    }
  }

  async isValidResource(resource) {
    // Implement your resource validation logic here
    // For example, check if a database connection is still active
    try {
        // Simulate a check
        await delay(10);
        return true; // Assume valid for this example
    } catch (error) {
        console.error("Resource is invalid:", error);
        return false;
    }
  }

  // ... (rest of the code) ...
}

            

              
                Copy
              
            
          

ಸಂಪನ್ಮೂಲ ಸಮಯ ಮೀರುವಿಕೆ (Timeout)

ಕಾರ್ಯಾಚರಣೆಗಳು ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಕಾಯುವುದನ್ನು ತಡೆಯಲು ನೀವು ಸಮಯ ಮೀರುವಿಕೆ (timeout) ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಅಳವಡಿಸಲು ಬಯಸಬಹುದು. ಒಂದು ಕಾರ್ಯಾಚರಣೆಯು ಸಮಯ ಮೀರುವಿಕೆಯನ್ನು ಮೀರಿದರೆ, ನೀವು ಪ್ರಾಮಿಸ್ ಅನ್ನು ತಿರಸ್ಕರಿಸಬಹುದು ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ದೋಷವನ್ನು ನಿಭಾಯಿಸಬಹುದು.

            
class ResourcePool {
    // ... (previous code) ...

    async acquire(timeout = 5000) { // Default timeout of 5 seconds
        return new Promise((resolve, reject) => {
            let timeoutId;

            const acquireResource = () => {
                if (this.availableResources.length > 0) {
                    const resource = this.availableResources.pop();
                    this.acquiredResources.add(resource);
                    clearTimeout(timeoutId);
                    resolve(resource);
                } else {
                    // Resource not immediately available, try again after a short delay
                    setTimeout(acquireResource, 50);
                }
            };

            timeoutId = setTimeout(() => {
                reject(new Error("Timeout acquiring resource from pool."));
            }, timeout);

            acquireResource(); // Start trying to acquire immediately
        });
    }

    // ... (rest of the code) ...
}

(async () => {
    const poolSize = 2;
    const dbPool = new ResourcePool(createDatabaseConnection, closeDatabaseConnection, poolSize);

    try {
        const connection = await dbPool.acquire(2000); // Acquire with a 2-second timeout
        console.log("Acquired connection:", connection.id);
        dbPool.release(connection);
    } catch (error) {
        console.error("Error acquiring connection:", error.message);
    }

    await dbPool.destroy();
})();

            

              
                Copy
              
            
          

ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ಮೆಟ್ರಿಕ್ಸ್

ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ನ ಬಳಕೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ಮೆಟ್ರಿಕ್ಸ್ ಅನ್ನು ಅಳವಡಿಸಿ. ಇದು ನಿಮಗೆ ಅಡೆತಡೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಪೂಲ್ ಗಾತ್ರ ಹಾಗೂ ಸಂಪನ್ಮೂಲ ಹಂಚಿಕೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

• ಲಭ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳ ಸಂಖ್ಯೆ.
• ಪಡೆದ ಸಂಪನ್ಮೂಲಗಳ ಸಂಖ್ಯೆ.
• ಬಾಕಿ ಇರುವ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆ.
• ಸರಾಸರಿ ಸ್ವಾಧೀನ ಸಮಯ.

ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

• ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ ಪೂಲಿಂಗ್: ಕನ್‌ಕರೆಂಟ್ ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳ ಪೂಲ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು. ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ಅಥವಾ ವಿಷಯ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಗಳಂತಹ ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಸಂವಹನ ನಡೆಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಇದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಸೈಟ್ ಲೇಟೆನ್ಸಿಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ವಿವಿಧ ಪ್ರದೇಶಗಳಿಗೆ ವಿಭಿನ್ನ ಡೇಟಾಬೇಸ್ ಪೂಲ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು.
• API ದರ ಸೀಮಿತಗೊಳಿಸುವಿಕೆ: ದರ ಮಿತಿಗಳನ್ನು ಮೀರುವುದನ್ನು ತಪ್ಪಿಸಲು ಬಾಹ್ಯ API ಗಳಿಗೆ ಮಾಡಿದ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿಯಂತ್ರಿಸುವುದು. ಅನೇಕ API ಗಳು, ವಿಶೇಷವಾಗಿ ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ಅಥವಾ ಕ್ಲೌಡ್ ಸೇವೆಗಳಿಂದ ಬಂದವುಗಳು, ದುರುಪಯೋಗವನ್ನು ತಡೆಯಲು ದರ ಮಿತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತವೆ. ಲಭ್ಯವಿರುವ API ಟೋಕನ್‌ಗಳು ಅಥವಾ ಸಂಪರ್ಕ ಸ್ಲಾಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಬಳಸಬಹುದು. ಅನೇಕ ವಿಮಾನಯಾನ API ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಟ್ರಾವೆಲ್ ಬುಕಿಂಗ್ ಸೈಟ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ; ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಕನ್‌ಕರೆಂಟ್ API ಕರೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಫೈಲ್ ಪ್ರಕ್ರಿಯೆ: ಡಿಸ್ಕ್ I/O ಅಡೆತಡೆಗಳನ್ನು ತಡೆಯಲು ಕನ್‌ಕರೆಂಟ್ ಫೈಲ್ ಓದುವ/ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸುವುದು. ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ಅಥವಾ ಕನ್‌ಕರೆನ್ಸಿ ಮಿತಿಗಳನ್ನು ಹೊಂದಿರುವ ಶೇಖರಣಾ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಮಾಧ್ಯಮ ಟ್ರಾನ್ಸ್‌ಕೋಡಿಂಗ್ ಸೇವೆಯು ಏಕಕಾಲೀನ ವೀಡಿಯೊ ಎನ್‌ಕೋಡಿಂಗ್ ಪ್ರಕ್ರಿಯೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸಲು ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಬಳಸಬಹುದು.
• ವೆಬ್ ಸಾಕೆಟ್ ಸಂಪರ್ಕ ನಿರ್ವಹಣೆ: ವಿಭಿನ್ನ ಸರ್ವರ್‌ಗಳು ಅಥವಾ ಸೇವೆಗಳಿಗೆ ವೆಬ್‌ಸಾಕೆಟ್ ಸಂಪರ್ಕಗಳ ಪೂಲ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು. ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ತೆರೆಯಲಾದ ಸಂಪರ್ಕಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸಬಹುದು. ಉದಾಹರಣೆ: ಚಾಟ್ ಸರ್ವರ್ ಅಥವಾ ರಿಯಲ್ ಟೈಮ್ ಟ್ರೇಡಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್.

ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ಗಳಿಗೆ ಪರ್ಯಾಯಗಳು

ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ಗಳು ಪರಿಣಾಮಕಾರಿಯಾಗಿದ್ದರೂ, ಕನ್‌ಕರೆನ್ಸಿ ಮತ್ತು ಸಂಪನ್ಮೂಲ ಬಳಕೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಇತರ ವಿಧಾನಗಳಿವೆ:

• ಕ್ಯೂಗಳು (Queues): ಉತ್ಪಾದಕರು ಮತ್ತು ಗ್ರಾಹಕರನ್ನು ಬೇರ್ಪಡಿಸಲು ಸಂದೇಶ ಕ್ಯೂ ಬಳಸಿ, ಸಂದೇಶಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ದರವನ್ನು ನಿಯಂತ್ರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. RabbitMQ ಅಥವಾ Kafka ದಂತಹ ಸಂದೇಶ ಕ್ಯೂಗಳನ್ನು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.
• ಸೆಮಾಫೋರ್‌ಗಳು (Semaphores): ಸೆಮಾಫೋರ್ ಎನ್ನುವುದು ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಪ್ರಿಮಿಟಿವ್ ಆಗಿದ್ದು, ಇದನ್ನು ಹಂಚಿಕೆಯ ಸಂಪನ್ಮೂಲಕ್ಕೆ ಕನ್‌ಕರೆಂಟ್ ಪ್ರವೇಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸಲು ಬಳಸಬಹುದು.
• ಕನ್‌ಕರೆನ್ಸಿ ಲೈಬ್ರರಿಗಳು: `p-limit` ನಂತಹ ಲೈಬ್ರರಿಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಕನ್‌ಕರೆನ್ಸಿಯನ್ನು ಸೀಮಿತಗೊಳಿಸಲು ಸರಳ API ಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ.

ವಿಧಾನದ ಆಯ್ಕೆಯು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.

ತೀರ್ಮಾನ

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಸಹಾಯಕ ಫಂಕ್ಷನ್‌ಗಳು, ಸಂಪನ್ಮೂಲ ಪೂಲ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಾಗ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅಸಿಂಕ್ರೊನಸ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಬಲ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಕನ್‌ಕರೆನ್ಸಿಯನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ಸಂಪನ್ಮೂಲಗಳ ಕೊರತೆಯನ್ನು ತಡೆಯುವ ಮೂಲಕ ಮತ್ತು ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಸಮರ್ಥ ಸಂಪನ್ಮೂಲ ಬಳಕೆಯ ಅಗತ್ಯವಿರುವ I/O-ಬೌಂಡ್ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ನಿಮ್ಮ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು, ಸಮಯ ಮೀರುವಿಕೆ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಅಳವಡಿಸಲು ಮತ್ತು ಅತ್ಯುತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಬಳಕೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮರೆಯದಿರಿ. ಈ ತತ್ವಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಅನ್ವಯಿಸುವ ಮೂಲಕ, ಆಧುನಿಕ ವೆಬ್ ಅಭಿವೃದ್ಧಿಯ ಬೇಡಿಕೆಗಳನ್ನು ನಿಭಾಯಿಸಬಲ್ಲ ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಅಸಿಂಕ್ರೊನಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನೀವು ನಿರ್ಮಿಸಬಹುದು.